PC Pro 1997 December/PC Pro December 1997 CD-Rom coverdisc.iso/symantec/dbAnywh/JAVA.BIN/CLASSES.ZIP/sun/tools/ttydebug/TTY.class

Java Class File | 1996-12-14 | 27.4 KB | 1,446 lines

package sun.tools.ttydebug;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import sun.tools.debug.DebuggerCallback;
import sun.tools.debug.NoSuchLineNumberException;
import sun.tools.debug.RemoteArray;
import sun.tools.debug.RemoteClass;
import sun.tools.debug.RemoteDebugger;
import sun.tools.debug.RemoteField;
import sun.tools.debug.RemoteInt;
import sun.tools.debug.RemoteObject;
import sun.tools.debug.RemoteStackFrame;
import sun.tools.debug.RemoteStackVariable;
import sun.tools.debug.RemoteThread;
import sun.tools.debug.RemoteThreadGroup;
import sun.tools.debug.RemoteValue;

public class TTY implements DebuggerCallback {
   RemoteDebugger debugger;
   RemoteThread currentThread;
   RemoteThreadGroup currentThreadGroup;
   PrintStream out;
   PrintStream console;
   private String lastArgs;

   private RemoteThread indexToThread(int var1) throws Exception {
      this.setDefaultThreadGroup();
      RemoteThread[] var2 = this.currentThreadGroup.listThreads(true);
      return var1 != 0 && var1 <= var2.length ? var2[var1 - 1] : null;
   }

   private int parseThreadId(String var1) throws Exception {
      if (var1.startsWith("t@")) {
         var1 = var1.substring(2);
      }

      int var2;
      try {
         var2 = Integer.valueOf(var1);
      } catch (NumberFormatException var3) {
         var2 = 0;
      }

      if (this.indexToThread(var2) == null) {
         this.out.println("\"" + var1 + "\" is not a valid thread id.");
         return 0;
      } else {
         return var2;
      }
   }

   private void printPrompt() throws Exception {
      if (this.currentThread == null) {
         this.out.print("> ");
      } else {
         this.out.print(this.currentThread.getName() + "[" + (this.currentThread.getCurrentFrameIndex() + 1) + "] ");
      }

      this.out.flush();
   }

   public synchronized void printToConsole(String var1) throws Exception {
      this.console.print(var1);
      this.console.flush();
   }

   public void breakpointEvent(RemoteThread var1) throws Exception {
      this.out.print("\nBreakpoint hit: ");
      RemoteStackFrame[] var2 = var1.dumpStack();
      if (var2.length > 0) {
         this.out.println(var2[0].toString());
         this.currentThread = var1;
      } else {
         this.out.println("Invalid thread specified in breakpoint.");
      }

      this.printPrompt();
   }

   public void exceptionEvent(RemoteThread var1, String var2) throws Exception {
      this.out.println("\n" + var2);
      var1.setCurrentFrameIndex(0);
      this.currentThread = var1;
      this.printPrompt();
   }

   public void threadDeathEvent(RemoteThread var1) throws Exception {
      this.out.println("\n" + var1.getName() + " died.");
      if (var1 == this.currentThread) {
         this.currentThread = null;
      }

      this.printPrompt();
   }

   public void quitEvent() throws Exception {
      String var1 = null;
      if (this.lastArgs != null) {
         StringTokenizer var2 = new StringTokenizer(this.lastArgs);
         if (var2.hasMoreTokens()) {
            var1 = new String("\n" + var2.nextToken() + " exited");
         }
      }

      if (var1 == null) {
         var1 = new String("\nThe application exited");
      }

      this.out.println(var1);
      this.currentThread = null;
      System.exit(0);
   }

   void classes() throws Exception {
      RemoteClass[] var1 = this.debugger.listClasses();
      this.out.println("** classes list **");

      for(int var2 = 0; var2 < var1.length; ++var2) {
         this.out.println(var1[var2].description());
      }

   }

   void methods(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("No class specified.");
      } else {
         String var2 = var1.nextToken();

         try {
            RemoteClass var3 = this.getClassFromToken(var2);
            RemoteField[] var4 = var3.getMethods();

            for(int var5 = 0; var5 < var4.length; ++var5) {
               this.out.println(var4[var5].getTypedName());
            }

         } catch (IllegalArgumentException var6) {
            this.out.println("\"" + var2 + "\" is not a valid id or class name.");
         }
      }
   }

   int printThreadGroup(RemoteThreadGroup var1, int var2) throws Exception {
      this.out.println("Group " + var1.getName() + ":");
      RemoteThread[] var3 = var1.listThreads(false);
      int var4 = 0;
      int var5 = 0;

      for(int var6 = 0; var6 < var3.length; ++var6) {
         int var7 = var3[var6].description().length();
         if (var7 > var4) {
            var4 = var7;
         }

         String var8 = var3[var6].getName();
         int var9 = var8.lastIndexOf(46);
         if (var9 >= 0 && var8.length() > var9) {
            var8 = var8.substring(var9 + 1);
         }

         if (var8.length() > var5) {
            var5 = var8.length();
         }
      }

      for(int var14 = 0; var14 < var3.length; ++var14) {
         char[] var15 = new char[80];

         for(int var17 = 0; var17 < 79; ++var17) {
            var15[var17] = ' ';
         }

         var15[79] = 0;
         StringBuffer var10 = new StringBuffer();
         var10.append(var15);
         var10.insert(var14 + var2 + 1 < 10 ? 1 : 0, var14 + var2 + 1);
         var10.insert(2, ".");
         int var11 = 4;
         var10.insert(var11, var3[var14].description());
         var11 += var4 + 1;
         String var12 = var3[var14].getName();
         int var13 = var12.lastIndexOf(46);
         if (var13 >= 0 && var12.length() > var13) {
            var12 = var12.substring(var13 + 1);
         }

         var10.insert(var11, var12);
         var11 += var5 + 1;
         var10.insert(var11, var3[var14].getStatus());
         var10.setLength(79);
         this.out.println(var10.toString());
      }

      RemoteThreadGroup[] var16 = this.debugger.listThreadGroups(var1);

      for(int var18 = 0; var18 < var16.length; ++var18) {
         if (var1 != var16[var18]) {
            var2 += this.printThreadGroup(var16[var18], var2 + var3.length);
         }
      }

      return var3.length;
   }

   private void setDefaultThreadGroup() throws Exception {
      if (this.currentThreadGroup == null) {
         RemoteThreadGroup[] var1 = this.debugger.listThreadGroups((RemoteThreadGroup)null);
         this.currentThreadGroup = var1[0];
      }

   }

   void threads(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.setDefaultThreadGroup();
         this.printThreadGroup(this.currentThreadGroup, 0);
      } else {
         String var2 = var1.nextToken();
         RemoteThreadGroup[] var3 = this.debugger.listThreadGroups((RemoteThreadGroup)null);

         for(int var4 = 0; var4 < var3.length; ++var4) {
            if (var2.equals(var3[var4].getName())) {
               this.printThreadGroup(var3[var4], 0);
               return;
            }
         }

         this.out.println(var2 + " is not a valid threadgroup name.");
      }
   }

   void threadGroups() throws Exception {
      RemoteThreadGroup[] var1 = this.debugger.listThreadGroups((RemoteThreadGroup)null);

      for(int var2 = 0; var2 < var1.length; ++var2) {
         this.out.println((new Integer(var2 + 1)).toString() + ". " + var1[var2].description() + " " + var1[var2].getName());
      }

   }

   void setThread(int var1) throws Exception {
      this.setDefaultThreadGroup();
      RemoteThread var2 = this.indexToThread(var1);
      if (var2 == null) {
         this.out.println("\"" + var1 + "\" is not a valid thread id.");
      } else {
         this.currentThread = var2;
      }
   }

   void thread(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("Thread number not specified.");
      } else {
         int var2 = this.parseThreadId(var1.nextToken());
         if (var2 != 0) {
            this.setThread(var2);
         }
      }
   }

   void threadGroup(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("Threadgroup name not specified.");
      } else {
         String var2 = var1.nextToken();
         RemoteThreadGroup[] var3 = this.debugger.listThreadGroups((RemoteThreadGroup)null);

         for(int var4 = 0; var4 < var3.length; ++var4) {
            if (var2.equals(var3[var4].getName())) {
               this.currentThreadGroup = var3[var4];
               return;
            }
         }

         this.out.println(var2 + " is not a valid threadgroup name.");
      }
   }

   void run(StringTokenizer var1) throws Exception {
      String[] var2 = new String[100];
      int var3 = 0;
      if (!var1.hasMoreTokens() && this.lastArgs != null) {
         var1 = new StringTokenizer(this.lastArgs);
         this.out.println("run " + this.lastArgs);
      }

      while(var1.hasMoreTokens()) {
         var2[var3++] = var1.nextToken();
         if (var3 == 1) {
            RemoteClass var4 = this.debugger.findClass(var2[0]);
            if (var4 == null) {
               this.out.println("Could not load the " + var2[0] + " class.");
               return;
            }

            var2[0] = var4.getName();
         }
      }

      if (var3 > 0) {
         RemoteThreadGroup var5 = this.debugger.run(var3, var2);
         if (var5 != null) {
            this.currentThreadGroup = var5;
            this.setThread(1);
            this.out.println("running ...");
         } else {
            this.out.println(var2[0] + " failed.");
         }
      } else {
         this.out.println("No class name specified.");
      }
   }

   void load(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("Class name not specified.");
      } else {
         String var2 = var1.nextToken();
         RemoteClass var3 = this.debugger.findClass(var2);
         if (var3 == null) {
            this.out.print(var2 + " not found");
            this.out.println(var2.indexOf(46) > 0 ? " (try the full name)" : "");
         } else {
            this.out.println(var3.toString());
         }
      }
   }

   void suspend(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.setDefaultThreadGroup();
         RemoteThread[] var6 = this.currentThreadGroup.listThreads(true);

         for(int var7 = 0; var7 < var6.length; ++var7) {
            var6[var7].suspend();
         }

         this.out.println("All (non-system) threads suspended.");
      } else {
         while(var1.hasMoreTokens()) {
            String var2 = var1.nextToken();

            int var3;
            try {
               var3 = Integer.valueOf(var2);
            } catch (NumberFormatException var5) {
               var3 = 0;
            }

            RemoteThread var4 = this.indexToThread(var3);
            if (var4 == null) {
               this.out.println("\"" + var2 + "\" is not a valid thread id.");
            } else {
               var4.suspend();
            }
         }

      }
   }

   void resume(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.setDefaultThreadGroup();
         RemoteThread[] var6 = this.currentThreadGroup.listThreads(true);

         for(int var7 = 0; var7 < var6.length; ++var7) {
            var6[var7].resume();
         }

         if (this.currentThread != null) {
            this.currentThread.resetCurrentFrameIndex();
         }

         this.out.println("All threads resumed.");
      } else {
         while(var1.hasMoreTokens()) {
            String var2 = var1.nextToken();

            int var3;
            try {
               var3 = Integer.valueOf(var2);
            } catch (NumberFormatException var5) {
               var3 = 0;
            }

            RemoteThread var4 = this.indexToThread(var3);
            if (var4 == null) {
               this.out.println("\"" + var2 + "\" is not a valid thread id.");
            } else {
               var4.resume();
               if (var4 == this.currentThread) {
                  this.currentThread.resetCurrentFrameIndex();
               }
            }
         }

      }
   }

   void cont() throws Exception {
      if (this.currentThread == null) {
         this.out.println("Nothing suspended.");
      } else {
         this.setDefaultThreadGroup();
         RemoteThread[] var1 = this.currentThreadGroup.listThreads(true);

         for(int var2 = 0; var2 < var1.length; ++var2) {
            var1[var2].cont();
         }

         this.currentThread.resetCurrentFrameIndex();
      }
   }

   void step() throws Exception {
      if (this.currentThread == null) {
         this.out.println("Nothing suspended.");
      } else {
         try {
            this.currentThread.step(true);
         } catch (IllegalAccessError var1) {
            this.out.println("Current thread is not at breakpoint.");
         }
      }
   }

   void next() throws Exception {
      if (this.currentThread == null) {
         this.out.println("Nothing suspended.");
      } else {
         try {
            this.currentThread.next();
         } catch (IllegalAccessError var1) {
            this.out.println("Current thread is not at breakpoint.");
         }
      }
   }

   void kill(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("Usage: kill <threadgroup name> or <thread id>");
      } else {
         while(var1.hasMoreTokens()) {
            String var2 = var1.nextToken();

            int var3;
            try {
               var3 = Integer.valueOf(var2);
            } catch (NumberFormatException var7) {
               var3 = 0;
            }

            RemoteThread var4 = this.indexToThread(var3);
            if (var4 != null) {
               this.out.println("killing thread: " + var4.getName());
               var4.stop();
               return;
            }

            RemoteThreadGroup[] var5 = this.debugger.listThreadGroups((RemoteThreadGroup)null);
            var5 = this.debugger.listThreadGroups(var5[0]);

            for(int var6 = 0; var6 < var5.length; ++var6) {
               if (var5[var6].getName().equals(var2)) {
                  this.out.println("killing threadgroup: " + var2);
                  var5[var6].stop();
                  return;
               }
            }

            this.out.println("\"" + var2 + "\" is not a valid threadgroup or id.");
         }

      }
   }

   void catchException(StringTokenizer var1) throws Exception {
      if (var1.hasMoreTokens()) {
         String var5 = var1.nextToken();

         try {
            RemoteClass var6 = this.getClassFromToken(var5);
            var6.catchExceptions();
         } catch (Exception var4) {
            this.out.println("Invalid exception class name: " + var5);
         }
      } else {
         String[] var2 = this.debugger.getExceptionCatchList();

         for(int var3 = 0; var3 < var2.length; ++var3) {
            this.out.print("  " + var2[var3]);
            if ((var3 & 4) == 3 || var3 == var2.length - 1) {
               this.out.println();
            }
         }

      }
   }

   void ignoreException(StringTokenizer var1) throws Exception {
      if (var1.hasMoreTokens()) {
         String var5 = var1.nextToken();

         try {
            RemoteClass var6 = this.getClassFromToken(var5);
            var6.ignoreExceptions();
         } catch (Exception var4) {
            this.out.println("Invalid exception class name: " + var5);
         }
      } else {
         String[] var2 = this.debugger.getExceptionCatchList();

         for(int var3 = 0; var3 < var2.length; ++var3) {
            this.out.print("  " + var2[var3]);
            if ((var3 & 4) == 3 || var3 == var2.length - 1) {
               this.out.println();
            }
         }

      }
   }

   // $FF: renamed from: up (java.util.StringTokenizer) void
   void method_0(StringTokenizer var1) throws Exception {
      if (this.currentThread == null) {
         this.out.println("Current thread not set.");
      } else {
         int var2 = 1;
         if (var1.hasMoreTokens()) {
            String var3 = var1.nextToken();

            int var4;
            try {
               var4 = Integer.valueOf(var3);
            } catch (NumberFormatException var7) {
               var4 = 0;
            }

            if (var4 == 0) {
               this.out.println("Usage: up [n frames]");
               return;
            }

            var2 = var4;
         }

         try {
            this.currentThread.up(var2);
         } catch (IllegalAccessError var5) {
            this.out.println("Thread isn't suspended.");
         } catch (ArrayIndexOutOfBoundsException var6) {
            this.out.println("End of stack.");
         }
      }
   }

   void down(StringTokenizer var1) throws Exception {
      if (this.currentThread == null) {
         this.out.println("Current thread not set.");
      } else {
         int var2 = 1;
         if (var1.hasMoreTokens()) {
            String var3 = var1.nextToken();

            int var4;
            try {
               var4 = Integer.valueOf(var3);
            } catch (NumberFormatException var7) {
               var4 = 0;
            }

            if (var4 == 0) {
               this.out.println("usage: down [n frames]");
               return;
            }

            var2 = var4;
         }

         try {
            this.currentThread.down(var2);
         } catch (IllegalAccessError var5) {
            this.out.println("Thread isn't suspended.");
         } catch (ArrayIndexOutOfBoundsException var6) {
            this.out.println("End of stack.");
         }
      }
   }

   void dumpStack(RemoteThread var1) throws Exception {
      RemoteStackFrame[] var2 = var1.dumpStack();
      if (var2.length == 0) {
         this.out.println("Thread is not running (no stack).");
      } else {
         int var3 = var2.length;

         for(int var4 = var1.getCurrentFrameIndex(); var4 < var3; ++var4) {
            this.out.print("  [" + (var4 + 1) + "] ");
            this.out.println(var2[var4].toString());
         }

      }
   }

   void where(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         if (this.currentThread == null) {
            this.out.println("No thread specified.");
         } else {
            this.dumpStack(this.currentThread);
         }
      } else {
         String var2 = var1.nextToken();
         if (!var2.toLowerCase().equals("all")) {
            int var5 = this.parseThreadId(var2);
            if (var5 != 0) {
               this.dumpStack(this.indexToThread(var5));
            }
         } else {
            this.setDefaultThreadGroup();
            RemoteThread[] var3 = this.currentThreadGroup.listThreads(true);

            for(int var4 = 0; var4 < var3.length; ++var4) {
               this.out.println(var3[var4].getName() + ": ");
               this.dumpStack(var3[var4]);
            }

         }
      }
   }

   void trace(String var1, StringTokenizer var2) throws Exception {
      if (!var2.hasMoreTokens()) {
         this.out.println("(i)trace < \"on\" | \"off\" >");
      } else {
         String var3 = var2.nextToken();
         boolean var4;
         if (var3.equals("on")) {
            var4 = true;
         } else {
            if (!var3.equals("off")) {
               this.out.println("(i)trace < \"on\" | \"off\" >");
               return;
            }

            var4 = false;
         }

         if (var1.equals("trace")) {
            this.debugger.trace(var4);
         } else {
            this.debugger.itrace(var4);
         }
      }
   }

   void memory() throws Exception {
      this.out.println("Free: " + this.debugger.freeMemory() + ", total: " + this.debugger.totalMemory());
   }

   // $FF: renamed from: gc () void
   void method_1() throws Exception {
      RemoteObject[] var1 = new RemoteObject[]{this.currentThread, this.currentThreadGroup};
      this.debugger.gc(var1);
   }

   private RemoteClass getClassFromToken(String var1) throws Exception {
      Object var2;
      if (!var1.startsWith("0x") && !Character.isDigit(var1.charAt(0))) {
         var2 = this.debugger.findClass(var1);
         if (var2 == null) {
            throw new IllegalArgumentException();
         }
      } else {
         int var3;
         try {
            var3 = RemoteValue.fromHex(var1);
         } catch (NumberFormatException var4) {
            var3 = 0;
         }

         if (var3 == 0 || (var2 = this.debugger.get(new Integer(var3))) == null) {
            throw new IllegalArgumentException();
         }

         if (!(var2 instanceof RemoteClass)) {
            throw new IllegalArgumentException();
         }
      }

      return (RemoteClass)var2;
   }

   void listBreakpoints() throws Exception {
      String[] var1 = this.debugger.listBreakpoints();
      if (var1.length <= 0) {
         this.out.println("No breakpoints set.");
      } else {
         this.out.println("Current breakpoints set:");

         for(int var2 = 0; var2 < var1.length; ++var2) {
            this.out.println("\t" + var1[var2]);
         }

      }
   }

   void stop(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.listBreakpoints();
      } else {
         Object var2 = null;

         try {
            String var3 = var1.nextToken();
            if (var3.equals("at")) {
               boolean var4 = true;
            } else {
               if (!var3.equals("in")) {
                  this.out.println("Usage: stop at <class>:<line_number> or");
                  this.out.println("       stop in <class>.<method_name>");
                  return;
               }

               boolean var17 = false;
            }

            if (var3.equals("at")) {
               String var16 = var1.nextToken(": \t\n\r");
               RemoteClass var19 = this.getClassFromToken(var16);
               String var20 = var1.nextToken();
               int var22 = Integer.valueOf(var20);
               String var23 = var19.setBreakpointLine(var22);
               if (var23.length() > 0) {
                  this.out.println(var23);
               } else {
                  this.out.println("Breakpoint set at " + var19.getName() + ":" + var22);
               }
            } else {
               String var14 = var1.nextToken(": \t\n\r");
               Object var5 = null;
               String var6 = null;

               try {
                  var18 = this.getClassFromToken(var14);
               } catch (IllegalArgumentException var10) {
                  int var7 = var14.lastIndexOf(".");
                  if (var7 == -1) {
                     this.out.println("\"" + var14 + "\" is not a valid id or class name.");
                     return;
                  }

                  var6 = var14.substring(var7 + 1);
                  var14 = var14.substring(0, var7);
                  var18 = this.getClassFromToken(var14);
               }

               if (var6 == null) {
                  var6 = var1.nextToken();
               }

               RemoteField var21;
               try {
                  var21 = var18.getMethod(var6);
               } catch (NoSuchMethodException var9) {
                  this.out.println("Class " + var18.getName() + " doesn't have a method " + var6);
                  return;
               }

               String var8 = var18.setBreakpointMethod(var21);
               if (var8.length() > 0) {
                  this.out.println(var8);
               } else {
                  this.out.println("Breakpoint set in " + var18.getName() + "." + var6);
               }
            }
         } catch (NoSuchElementException var11) {
            this.out.println("Usage: stop at <class>:<line_number> or");
            this.out.println("       stop in <class>.<method_name>");
         } catch (NumberFormatException var12) {
            this.out.println("Invalid line number.");
         } catch (IllegalArgumentException var13) {
            this.out.println("\"" + var2 + "\" is not a valid id or class name.");
         }
      }
   }

   void clear(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.listBreakpoints();
      } else {
         Object var2 = null;
         Object var3 = null;
         Object var4 = null;

         try {
            String var13 = var1.nextToken(": \t\n\r");

            try {
               var17 = this.getClassFromToken(var13);
            } catch (IllegalArgumentException var9) {
               int var5 = var13.lastIndexOf(".");
               if (var5 == -1) {
                  this.out.println("\"" + var13 + "\" is not a valid id or class name.");
                  return;
               }

               String var15 = var13.substring(var5 + 1);
               var13 = var13.substring(0, var5);
               RemoteClass var16 = this.getClassFromToken(var13);

               RemoteField var6;
               try {
                  var6 = var16.getMethod(var15);
               } catch (NoSuchMethodException var8) {
                  this.out.println("\"" + var15 + "\" is not a valid method name of class " + var16.getName());
                  return;
               }

               String var7 = var16.clearBreakpointMethod(var6);
               if (var7.length() > 0) {
                  this.out.println(var7);
                  return;
               }

               this.out.println("Breakpoint cleared at " + var16.getName() + "." + var15);
               return;
            }

            String var18 = var1.nextToken();
            int var19 = Integer.valueOf(var18);
            String var20 = var17.clearBreakpointLine(var19);
            if (var20.length() > 0) {
               this.out.println(var20);
            } else {
               this.out.println("Breakpoint cleared at " + var17.getName() + ": " + var19);
            }
         } catch (NoSuchElementException var10) {
            this.out.println("Usage: clear <class>:<line_number>");
            this.out.println("   or: clear <class>.<method>");
         } catch (NumberFormatException var11) {
            this.out.println("Usage: clear <class>:<line_number>");
            this.out.println("   or: clear <class>.<method>");
         } catch (IllegalArgumentException var12) {
            this.out.println("\"" + var2 + "\" is not a valid id or class name.");
         }
      }
   }

   void list(StringTokenizer var1) throws Exception {
      Object var2 = null;
      if (this.currentThread == null) {
         this.out.println("No thread specified.");
      } else {
         try {
            var16 = this.currentThread.getCurrentFrame();
         } catch (IllegalAccessError var14) {
            this.out.println("Current thread isn't suspended.");
            return;
         } catch (ArrayIndexOutOfBoundsException var15) {
            this.out.println("Thread is not running (no stack).");
            return;
         }

         int var3;
         if (var1.hasMoreTokens()) {
            String var4 = var1.nextToken();

            try {
               var3 = Integer.valueOf(var4);
            } catch (NumberFormatException var13) {
               try {
                  var3 = var16.getRemoteClass().getMethodLineNumber(var4);
               } catch (NoSuchMethodException var11) {
                  this.out.println(var4 + " is not a valid line number or " + "method name for class " + var16.getRemoteClass().getName());
                  return;
               } catch (NoSuchLineNumberException var12) {
                  this.out.println("Line number information not found in " + var16.getRemoteClass().getName());
                  return;
               }
            }
         } else {
            var3 = var16.getLineNumber();
         }

         int var17 = var3 > 4 ? var3 - 4 : 1;
         int var5 = var17 + 9;
         InputStream var6 = var16.getRemoteClass().getSourceFile();
         if (var6 == null) {
            this.out.println("Unable to find " + var16.getRemoteClass().getSourceFileName());
         } else {
            DataInputStream var7 = new DataInputStream(var6);
            String var8 = null;

            for(int var9 = 1; var9 <= var17; ++var9) {
               var8 = var7.readLine();
            }

            if (var8 == null) {
               this.out.println((new Integer(var3)).toString() + " is an invalid line number for the file " + var16.getRemoteClass().getSourceFileName());
            }

            for(int var10 = var17; var10 < var5 && var8 != null; ++var10) {
               this.out.print((new Integer(var10)).toString() + "\t" + (var10 == var3 ? "=> " : "   "));
               this.out.println(var8);
               var8 = var7.readLine();
            }

         }
      }
   }

   void use(StringTokenizer var1) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println(this.debugger.getSourcePath());
      } else {
         this.debugger.setSourcePath(var1.nextToken());
      }
   }

   void locals() throws Exception {
      if (this.currentThread == null) {
         this.out.println("No default thread specified: use the \"thread\" command first.");
      } else {
         RemoteStackVariable[] var1 = this.currentThread.getStackVariables();
         if (var1 != null && var1.length != 0) {
            this.out.println("Method arguments:");

            for(int var2 = 0; var2 < var1.length; ++var2) {
               if (var1[var2].methodArgument()) {
                  this.out.print("  " + var1[var2].getName());
                  if (var1[var2].inScope()) {
                     this.out.println(" = " + var1[var2].getValue().toString());
                  } else {
                     this.out.println(" is not in scope (WHAT???)");
                  }
               }
            }

            this.out.println("Local variables:");

            for(int var3 = 0; var3 < var1.length; ++var3) {
               if (!var1[var3].methodArgument()) {
                  this.out.print("  " + var1[var3].getName());
                  if (var1[var3].inScope()) {
                     this.out.println(" = " + var1[var3].getValue().toString());
                  } else {
                     this.out.println(" is not in scope.");
                  }
               }
            }

         } else {
            this.out.println("No local variables: try compiling with -g");
         }
      }
   }

   boolean print(StringTokenizer var1, boolean var2, boolean var3) throws Exception {
      if (!var1.hasMoreTokens()) {
         this.out.println("No objects specified.");
         return false;
      } else {
         while(var1.hasMoreTokens()) {
            Object var5 = null;
            String var6 = ".[(";
            String var7 = var1.nextToken();
            StringTokenizer var8 = new StringTokenizer(var7, var6, true);
            String var9 = var8.nextToken();
            if (var9.startsWith("t@")) {
               this.setDefaultThreadGroup();
               RemoteThread[] var30 = this.currentThreadGroup.listThreads(true);

               int var24;
               try {
                  var24 = Integer.valueOf(var9.substring(2));
               } catch (NumberFormatException var23) {
                  var24 = 0;
               }

               if (var24 <= 0 || var24 > var30.length) {
                  this.out.println("\"" + var9 + "\" is not a valid thread id.");
                  return false;
               }

               var5 = var30[var24 - 1];
            } else if (var9.startsWith("$s")) {
               int var29;
               try {
                  var29 = Integer.valueOf(var9.substring(2));
               } catch (NumberFormatException var22) {
                  this.out.println("\"" + var9 + "\" is not a valid slot.");
                  return false;
               }

               if (this.currentThread != null) {
                  RemoteStackVariable[] var12 = this.currentThread.getStackVariables();
                  if (var12 == null || var29 >= var12.length) {
                     this.out.println("\"" + var9 + "\" is not a valid slot.");
                     return false;
                  }

                  var5 = var12[var29].getValue();
               }
            } else if (!var9.startsWith("0x") && !Character.isDigit(var9.charAt(0))) {
               if (this.currentThread != null) {
                  RemoteStackVariable var11 = this.currentThread.getStackVariable(var9);
                  if (var11 != null && !var11.inScope()) {
                     this.out.println(var9 + " is not in scope.");
                     return false;
                  }

                  var5 = var11 == null ? null : var11.getValue();
               }

               if (var5 == null) {
                  if (!var9.equals("this")) {
                     String var28 = "this." + var9;
                     if (this.print(new StringTokenizer(var28), var2, true)) {
                        return true;
                     }
                  }

                  var5 = this.debugger.findClass(var9);
                  if (var5 == null) {
                     if (!var3) {
                        this.out.println("\"" + var7 + "\" is not a " + "valid id or class name.");
                     }

                     return false;
                  }
               }
            } else {
               int var4;
               try {
                  var4 = RemoteValue.fromHex(var9);
               } catch (NumberFormatException var19) {
                  var4 = 0;
               }

               if (var4 == 0 || (var5 = this.debugger.get(new Integer(var4))) == null) {
                  this.out.println("\"" + var9 + "\" is not a valid id.");
                  return false;
               }
            }

            RemoteInt var31 = new RemoteInt(-1);
            Object var32 = var31;
            String var13 = "";
            var9 = var8.hasMoreTokens() ? var8.nextToken() : null;

            while(var9 != null) {
               if (!var9.equals(".")) {
                  if (!var9.equals("[")) {
                     if (var9.equals("(")) {
                        this.out.println("print <method> not supported yet.");
                        return false;
                     }

                     this.out.println("invalid expression");
                     return false;
                  }

                  if (!var8.hasMoreTokens()) {
                     this.out.println("\"" + var7 + "\" is not a valid expression.");
                     return false;
                  }

                  var9 = var8.nextToken("]");

                  try {
                     int var14 = Integer.valueOf(var9);
                     var32 = ((RemoteArray)var32).getElement(var14);
                  } catch (NumberFormatException var20) {
                     this.out.println("\"" + var9 + "\" is not a valid decimal number.");
                     return false;
                  } catch (ArrayIndexOutOfBoundsException var21) {
                     this.out.println(var9 + " is out of bounds for " + ((RemoteValue)var5).description());
                     return false;
                  }

                  if (var32 != null && ((RemoteValue)var32).isObject()) {
                     var5 = var32;
                     var32 = var31;
                  }

                  if (!var8.hasMoreTokens() || !var8.nextToken().equals("]")) {
                     this.out.println("\"" + var7 + "\" is not a valid expression.");
                     return false;
                  }

                  var9 = var8.hasMoreTokens() ? var8.nextToken(var6) : null;
               } else {
                  if (!var8.hasMoreTokens()) {
                     this.out.println("\"" + var7 + "\" is not a valid expression.");
                     return false;
                  }

                  var9 = var8.nextToken();
                  if (var32 != var31) {
                     this.out.println("\"" + var13 + "\" is not an object.");
                     return false;
                  }

                  var13 = var9;
                  var32 = ((RemoteObject)var5).getFieldValue(var9);
                  if (var32 == null) {
                     this.out.println("\"" + var9 + "\" is not a valid field of " + ((RemoteValue)var5).description());
                     return false;
                  }

                  if (((RemoteValue)var32).isObject()) {
                     var5 = var32;
                     var32 = var31;
                  }

                  var9 = var8.hasMoreTokens() ? var8.nextToken() : null;
               }
            }

            this.out.print(var7 + " = ");
            if (var32 != var31) {
               this.out.println(var32 == null ? "null" : ((RemoteValue)var32).description());
            } else if (var2 && var5 instanceof RemoteObject) {
               this.out.println(((RemoteValue)var5).description() + " {");
               if (var5 instanceof RemoteClass) {
                  RemoteClass var33 = (RemoteClass)var5;
                  this.out.print("    superclass = ");
                  RemoteClass var15 = var33.getSuperclass();
                  this.out.println(var15 == null ? "null" : var15.description());
                  this.out.print("    loader = ");
                  RemoteObject var16 = var33.getClassLoader();
                  this.out.println(var16 == null ? "null" : var16.description());
                  RemoteClass[] var17 = var33.getInterfaces();
                  if (var17 != null && var17.length > 0) {
                     this.out.println("    interfaces:");

                     for(int var18 = 0; var18 < var17.length; ++var18) {
                        this.out.println("        " + var17[var18]);
                     }
                  }
               }

               RemoteField[] var34 = ((RemoteObject)var5).getFields();
               if (var5 instanceof RemoteClass && var34.length > 0) {
                  this.out.println();
               }

               for(int var35 = 0; var35 < var34.length; ++var35) {
                  String var36 = var34[var35].getTypedName();
                  String var37 = var34[var35].getModifiers();
                  this.out.print("    " + var37 + var36 + " = ");
                  RemoteValue var38 = ((RemoteObject)var5).getFieldValue(var35);
                  this.out.println(var38 == null ? "null" : var38.description());
               }

               this.out.println("}");
            } else {
               this.out.println(var5.toString());
            }
         }

         return true;
      }
   }

   void help() {
      this.out.println("** command list **");
      this.out.println("threads [threadgroup]     -- list threads");
      this.out.println("thread <thread id>        -- set default thread");
      this.out.println("suspend [thread id(s)]    -- suspend threads (default: all)");
      this.out.println("resume [thread id(s)]     -- resume threads (default: all)");
      this.out.println("where [thread id] | all   -- dump a thread's stack");
      this.out.println("threadgroups              -- list threadgroups");
      this.out.println("threadgroup <name>        -- set current threadgroup\n");
      this.out.println("print <id> [id(s)]        -- print object or field");
      this.out.println("dump <id> [id(s)]         -- print all object information\n");
      this.out.println("locals                    -- print all local variables in current stack frame\n");
      this.out.println("classes                   -- list currently known classes");
      this.out.println("methods <class id>        -- list a class's methods\n");
      this.out.println("stop in <class id>.<method> -- set a breakpoint in a method");
      this.out.println("stop at <class id>:<line> -- set a breakpoint at a line");
      this.out.println("up [n frames]             -- move up a thread's stack");
      this.out.println("down [n frames]           -- move down a thread's stack");
      this.out.println("clear <class id>:<line>   -- clear a breakpoint");
      this.out.println("step                      -- execute current line");
      this.out.println("cont                      -- continue execution from breakpoint\n");
      this.out.println("catch <class id>          -- break for the specified exception");
      this.out.println("ignore <class id>         -- ignore when the specified exception\n");
      this.out.println("list [line number|method] -- print source code");
      this.out.println("use [source file path]    -- display or change the source path\n");
      this.out.println("memory                    -- report memory usage");
      this.out.println("gc                        -- free unused objects\n");
      this.out.println("load classname            -- load Java class to be debugged");
      this.out.println("run <class> [args]        -- start execution of a loaded Java class");
      this.out.println("!!                        -- repeat last command");
      this.out.println("help (or ?)               -- list commands");
      this.out.println("exit (or quit)            -- exit debugger");
   }

   void executeCommand(StringTokenizer var1) {
      String var2 = var1.nextToken().toLowerCase();

      try {
         if (var2.equals("print")) {
            this.print(var1, false, false);
         } else if (var2.equals("dump")) {
            this.print(var1, true, false);
         } else if (var2.equals("locals")) {
            this.locals();
         } else if (var2.equals("classes")) {
            this.classes();
         } else if (var2.equals("methods")) {
            this.methods(var1);
         } else if (var2.equals("threads")) {
            this.threads(var1);
         } else if (var2.equals("thread")) {
            this.thread(var1);
         } else if (var2.equals("suspend")) {
            this.suspend(var1);
         } else if (var2.equals("resume")) {
            this.resume(var1);
         } else if (var2.equals("threadgroups")) {
            this.threadGroups();
         } else if (var2.equals("threadgroup")) {
            this.threadGroup(var1);
         } else if (var2.equals("catch")) {
            this.catchException(var1);
         } else if (var2.equals("ignore")) {
            this.ignoreException(var1);
         } else if (var2.equals("cont")) {
            this.cont();
         } else if (var2.equals("step")) {
            this.step();
         } else if (var2.equals("next")) {
            this.next();
         } else if (var2.equals("kill")) {
            this.kill(var1);
         } else if (var2.equals("where")) {
            this.where(var1);
         } else if (var2.equals("up")) {
            this.method_0(var1);
         } else if (var2.equals("down")) {
            this.down(var1);
         } else if (var2.equals("load")) {
            this.load(var1);
         } else if (var2.equals("run")) {
            this.run(var1);
         } else if (var2.equals("memory")) {
            this.memory();
         } else if (var2.equals("gc")) {
            this.method_1();
         } else if (!var2.equals("trace") && !var2.equals("itrace")) {
            if (var2.equals("stop")) {
               this.stop(var1);
            } else if (var2.equals("clear")) {
               this.clear(var1);
            } else if (var2.equals("list")) {
               this.list(var1);
            } else if (var2.equals("use")) {
               this.use(var1);
            } else if (!var2.equals("help") && !var2.equals("?")) {
               if (!var2.equals("quit") && !var2.equals("exit")) {
                  this.out.println("huh? Try help...");
               } else {
                  this.debugger.close();
                  System.exit(0);
               }
            } else {
               this.help();
            }
         } else {
            this.trace(var2, var1);
         }
      } catch (Exception var4) {
         this.out.println("Internal exception:");
         this.out.flush();
         ((Throwable)var4).printStackTrace();
      }
   }

   void readCommandFile(File var1) {
      try {
         if (var1.canRead()) {
            DataInputStream var2 = new DataInputStream(new FileInputStream(var1));

            String var3;
            while((var3 = var2.readLine()) != null) {
               StringTokenizer var4 = new StringTokenizer(var3);
               if (var4.hasMoreTokens()) {
                  this.executeCommand(var4);
               }
            }

            return;
         }
      } catch (IOException var5) {
      }

   }

   public TTY(String var1, String var2, String var3, String var4, PrintStream var5, PrintStream var6, boolean var7) throws Exception {
      System.out.println("Initializing jdb...");
      this.out = var5;
      this.console = var6;
      if (var2 == null) {
         this.debugger = new RemoteDebugger(var3, this, var7);
      } else {
         this.debugger = new RemoteDebugger(var1, var2, this, var7);
      }

      DataInputStream var8 = new DataInputStream(System.in);
      String var9 = null;
      if (var4 != null && var4.length() > 0) {
         StringTokenizer var10 = new StringTokenizer(var4);
         this.load(var10);
         this.lastArgs = var4;
      }

      Thread.currentThread().setPriority(5);
      File var13 = new File(System.getProperty("user.home") + System.getProperty("file.separator") + "jdb.ini");
      if (!var13.canRead()) {
         var13 = new File(System.getProperty("user.home") + System.getProperty("file.separator") + ".jdbrc");
      }

      this.readCommandFile(var13);
      var13 = new File(System.getProperty("user.dir") + System.getProperty("file.separator") + "startup.jdb");
      this.readCommandFile(var13);

      while(true) {
         this.printPrompt();
         String var11 = var8.readLine();
         if (var11 == null) {
            this.out.println("Input stream closed.");
            return;
         }

         if (var11.startsWith("!!") && var9 != null) {
            var11 = var9 + var11.substring(2);
            this.out.println(var11);
         }

         StringTokenizer var12 = new StringTokenizer(var11);
         if (var12.hasMoreTokens()) {
            var9 = var11;
            this.executeCommand(var12);
         }
      }
   }

   public static void main(String[] var0) {
      String var1;
      try {
         var1 = InetAddress.getLocalHost().getHostName();
      } catch (Exception var12) {
         var1 = null;
      }

      if (var1 == null) {
         var1 = "localhost";
      }

      String var2 = null;
      String var3 = null;
      String var4 = "";
      String var5 = "";
      boolean var6 = false;

      for(int var7 = 0; var7 < var0.length; ++var7) {
         String var8 = var0[var7];
         if (var8.equals("-dbgtrace")) {
            var6 = true;
         } else if (!var8.equals("-cs") && !var8.equals("-checksource") && !var8.equals("-noasyncgc") && !var8.equals("-prof") && !var8.equals("-v") && !var8.equals("-verbose") && !var8.equals("-verify") && !var8.equals("-noverify") && !var8.equals("-verifyremote") && !var8.equals("-verbosegc") && !var8.startsWith("-ms") && !var8.startsWith("-mx") && !var8.startsWith("-ss") && !var8.startsWith("-oss") && !var8.startsWith("-D")) {
            if (var8.equals("-classpath")) {
               if (var7 == var0.length - 1) {
                  System.out.println("No classpath specified.");
                  System.exit(1);
               }

               StringBuffer var10000 = (new StringBuffer()).append(var5).append(var8).append(" ");
               ++var7;
               var5 = var10000.append(var0[var7]).append(" ").toString();
            } else if (var8.equals("-host")) {
               if (var7 == var0.length - 1) {
                  System.out.println("No host specified.");
                  System.exit(1);
               }

               ++var7;
               var2 = var0[var7];
            } else if (var8.equals("-password")) {
               if (var7 == var0.length - 1) {
                  System.out.println("No password specified.");
                  System.exit(1);
               }

               ++var7;
               var3 = var0[var7];
            } else {
               var4 = var4 + var8 + " ";
            }
         } else {
            var5 = var5 + var8 + " ";
         }
      }

      if (var2 != null && var3 == null) {
         System.out.println("A debug password must be specified for remote debugging.");
         System.exit(1);
      }

      if (var2 == null) {
         var2 = var1;
      }

      try {
         if (!var2.equals(var1) && var3.length() == 0) {
            System.out.println("No password supplied for accessing remote Java interpreter.");
            System.out.println("The password is reported by the remote interpreterwhen it is started.");
            System.exit(1);
         }

         new TTY(var2, var3, var5, var4, System.out, System.out, var6);
      } catch (SocketException var9) {
         System.out.println("Failed accessing debugging session on " + var2 + ": invalid password.");
      } catch (NumberFormatException var10) {
         System.out.println("Failed accessing debugging session on " + var2 + ": invalid password.");
      } catch (Exception var11) {
         System.out.print("Internal exception:  ");
         System.out.flush();
         ((Throwable)var11).printStackTrace();
      }
   }
}